import 'dart:io';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:image_picker/image_picker.dart';
import 'package:dio/dio.dart' as dio;
import 'dart:developer' as developer;
import '../../../common/utils/toast_util.dart';
import '../../../common/api/activity_api.dart';
import '../../../common/services/user_service.dart';
import '../../../common/services/amap_location_service.dart'; // 🗺️ 启用高德地图定位服务
import '../../../common/utils/permission_util.dart'; // 🎯 权限计算工具
import '../../../common/services/permission_service.dart';

import '../../play/plays/controller.dart';
import '../../system/main/controller.dart'; // 导入MainController

class PostEventController extends GetxController {
  PostEventController();

  // 标题
  final TextEditingController titleController = TextEditingController();
  final FocusNode titleFocusNode = FocusNode();
  
  // 人数
  final TextEditingController peopleCountController = TextEditingController();
  final FocusNode peopleCountFocusNode = FocusNode();
  
  // 活动详情
  final TextEditingController detailsController = TextEditingController();
  final FocusNode detailsFocusNode = FocusNode();
  
  // 地点相关（动态定位）
  RxString location = "正在获取位置...".obs;              // 地点描述
  RxDouble activityLatitude = 0.0.obs;                 // 活动纬度
  RxDouble activityLongitude = 0.0.obs;                // 活动经度
  RxBool isLocationLoading = false.obs;               // 定位加载状态
  RxBool isDefaultLocation = false.obs;               // 是否为默认位置
  
  // 开始时间
  Rx<DateTime?> startDate = Rx<DateTime?>(null);
  RxString startDateText = "".obs;
  
  // 结束时间
  Rx<DateTime?> endDate = Rx<DateTime?>(null);
  RxString endDateText = "".obs;
  
  // 限制选项
  final List<String> limitOptions = ["无限制", "男", "女"];
  RxString selectedLimit = "无限制".obs;
  
  // 消费方式
  final List<String> paymentOptions = ["我买单", "AA", "双方商议"];
  RxString selectedPayment = "我买单".obs;
  

  
  RxInt detailsLength = 0.obs;
  
  // 活动图片（支持多张图片，与发布评论保持一致）
  RxList<String> activityImages = <String>[].obs; // 活动图片列表

  // 加载状态
  RxBool isLoading = false.obs;
  RxBool isUploadingActivityImage = false.obs; // 活动图片上传状态

  // 图片选择器实例
  final ImagePicker _picker = ImagePicker();
  
  // 获取UserService实例
  UserService get userService => UserService.to;

  // 定位服务依赖（学习首页实现）
  late AmapLocationService _amapLocationService; // 🗺️ 高德地图定位服务
  late PermissionService _permissionService;

  // 位置信息（动态获取，不再使用固定坐标）
  double get latitude => activityLatitude.value != 0.0 ? activityLatitude.value : 37.463822; // 优先使用实时定位，降级为烟台坐标
  double get longitude => activityLongitude.value != 0.0 ? activityLongitude.value : 121.447935; // 优先使用实时定位，降级为烟台坐标

  // ✅ 用户信息（从UserService获取当前登录用户数据）
  int get publisherId => userService.currentUser?.userid ?? 0; // 优先使用真实用户ID，如果未登录则为0
  String get publisherNickname => userService.userName.isNotEmpty ? userService.userName : "默认用户"; // 优先使用真实用户名
  String get publisherAvatarUrl => userService.userAvatar; // 使用真实用户头像（保持字段名一致）
  String get publisherSignature => userService.userSignature; // 使用真实用户签名

  _initData() {
    // 初始化定位服务（学习首页实现）
    try {
      _amapLocationService = Get.find<AmapLocationService>();
      _permissionService = Get.find<PermissionService>();
      
      // 启动自动定位检查
      _autoLocationCheck();
      
      developer.log('🗺️ PostEventController定位服务初始化完成', name: 'PostEvent');
    } catch (e) {
      developer.log('💥 PostEventController定位服务初始化失败: $e', name: 'PostEvent');
      // 设置默认位置
      _setDefaultLocationInfo();
    }
    
    update(["post_event"]);
  }

  // 🗺️ 自动检查位置权限并定位（学习首页实现）
  Future<void> _autoLocationCheck() async {
    try {
      developer.log('🗺️ =============== 发布页面自动定位检查 ===============', name: 'PostEvent');
      developer.log('🔍 开始检查定位服务和权限状态...', name: 'PostEvent');
      
      // 检查权限状态
      final hasPermission = _permissionService.isLocationPermissionGranted;
      developer.log('📋 当前权限状态: $hasPermission', name: 'PostEvent');
      
      if (hasPermission) {
        developer.log('✅ 位置权限已授权，开始自动定位', name: 'PostEvent');
        await _performAutoLocation();
      } else {
        developer.log('⚠️ 位置权限未授权，静默请求权限', name: 'PostEvent');
        
        // 静默请求权限
        final isGranted = await _permissionService.requestLocationPermission();
        developer.log('📋 权限请求结果: $isGranted', name: 'PostEvent');
        
        if (isGranted) {
          developer.log('✅ 权限请求成功，开始自动定位', name: 'PostEvent');
          await _performAutoLocation();
        } else {
          developer.log('❌ 权限请求失败，使用默认位置', name: 'PostEvent');
          _setDefaultLocationInfo();
        }
      }
      
    } catch (e) {
      developer.log('💥 发布页面自动定位检查异常: $e', name: 'PostEvent');
      _setDefaultLocationInfo();
    } finally {
      developer.log('🏁 =============== 发布页面自动定位检查结束 ===============', name: 'PostEvent');
    }
  }

  // 🗺️ 执行自动定位（学习首页实现）
  Future<void> _performAutoLocation() async {
    try {
      isLocationLoading.value = true;
      location.value = "正在定位中...";
      
      developer.log('🎯 =============== 发布页面高德定位开始 ===============', name: 'PostEvent');
      
      // 使用高德定位服务
      final amapLocation = await _amapLocationService.startLocation(
        isOnceLocation: true,
        timeout: const Duration(seconds: 8),
      );
      
      developer.log('📬 高德定位服务返回结果: $amapLocation', name: 'PostEvent');
      
      if (amapLocation != null && amapLocation.success && _amapLocationService.isLocationValid(amapLocation)) {
        // 🎉 高德定位成功
        final address = _amapLocationService.formatAddress(amapLocation.address);
        
        // 更新位置信息
        location.value = address;
        isDefaultLocation.value = false;
        activityLatitude.value = amapLocation.latitude!;
        activityLongitude.value = amapLocation.longitude!;
        
        developer.log('🎉 发布页面高德定位成功!', name: 'PostEvent');
        developer.log('📍 坐标: ${amapLocation.latitude}, ${amapLocation.longitude}', name: 'PostEvent');
        developer.log('📍 地址: $address', name: 'PostEvent');
        
        // 显示成功提示
        ToastUtil.success('获取当前位置成功');
        
        return;
      } else {
        developer.log('❌ 发布页面高德定位失败', name: 'PostEvent');
        if (amapLocation != null) {
          developer.log('❌ 定位错误: ${amapLocation.errorMessage} (${amapLocation.errorCode})', name: 'PostEvent');
        }
      }
      
      // 定位失败，使用默认位置
      _setDefaultLocationInfo();
      
    } catch (e) {
      developer.log('💥 发布页面定位异常: $e', name: 'PostEvent');
      _setDefaultLocationInfo();
    } finally {
      isLocationLoading.value = false;
      developer.log('🏁 =============== 发布页面高德定位结束 ===============', name: 'PostEvent');
    }
  }

  // 设置默认位置信息（学习首页实现）
  void _setDefaultLocationInfo() {
    location.value = "山东省烟台市莱山区";
    isDefaultLocation.value = true;
    activityLatitude.value = 37.463822;
    activityLongitude.value = 121.447935;
    developer.log('🏠 发布页面使用默认位置: ${location.value}', name: 'PostEvent');
  }

  // 从地图页面更新位置信息（学习首页实现）
  void updateLocationFromMap(Map<String, dynamic> locationData) {
    try {
      developer.log('🗺️ =============== 发布页面接收地图位置数据 ===============', name: 'PostEvent');
      
      final address = locationData['address'] as String?;
      final lat = locationData['latitude'] as double?;
      final lng = locationData['longitude'] as double?;
      
      if (address != null && lat != null && lng != null) {
        // 更新位置信息
        location.value = address;
        isDefaultLocation.value = false;
        activityLatitude.value = lat;
        activityLongitude.value = lng;
        
        developer.log('✅ 发布页面位置信息更新成功:', name: 'PostEvent');
        developer.log('   地址: $address', name: 'PostEvent');
        developer.log('   坐标: $lat, $lng', name: 'PostEvent');
        
        // 显示成功提示
        ToastUtil.success('位置更新成功');
        
      } else {
        developer.log('❌ 地图返回的位置数据格式不正确', name: 'PostEvent');
      }
      
    } catch (e) {
      developer.log('💥 处理地图位置数据异常: $e', name: 'PostEvent');
    } finally {
      developer.log('🏁 =============== 发布页面地图位置数据处理结束 ===============', name: 'PostEvent');
    }
  }

  // 手动刷新位置（重新定位）
  Future<void> refreshLocation() async {
    if (isLocationLoading.value) return; // 防止重复请求
    
    developer.log('🔄 用户手动刷新位置', name: 'PostEvent');
    await _performAutoLocation();
  }

  /// 清除所有输入框的焦点
  void clearAllFocus() {
    titleFocusNode.unfocus();
    peopleCountFocusNode.unfocus();
    detailsFocusNode.unfocus();
    // 同时也调用全局的unfocus确保万无一失
    if (Get.context != null) {
      FocusScope.of(Get.context!).unfocus();
    }
  }

  // 打开日期时间选择器 - 简洁的两步式选择
  void openDateTimePicker(BuildContext context, bool isStartDate) async {
    // 首先清除所有输入框焦点并收起键盘
    clearAllFocus();
    // 添加短暂延迟确保键盘完全收起
    await Future.delayed(const Duration(milliseconds: 150));
    
    // 确定最小时间和初始时间
    DateTime minTime;
    DateTime initialTime;
    
    if (isStartDate) {
      minTime = DateTime.now();
      initialTime = startDate.value ?? DateTime.now();
    } else {
      minTime = startDate.value ?? DateTime.now();
      initialTime = endDate.value ?? minTime;
    }
    
    // 第一步：选择日期
    final DateTime? pickedDate = await showDatePicker(
      context: context,
      initialDate: initialTime,
      firstDate: minTime,
      lastDate: DateTime(2030, 12, 31),
      locale: const Locale('zh', 'CN'),
      builder: (context, child) {
        return Theme(
          data: ThemeData.light().copyWith(
            primaryColor: const Color(0xFFE33641),
            colorScheme: const ColorScheme.light(
              primary: Color(0xFFE33641),
            ),
          ),
          child: child!,
        );
      },
    );
    
    if (pickedDate != null) {
      // 第二步：选择时间
      if (!context.mounted) return;
      
      final TimeOfDay? pickedTime = await showTimePicker(
        context: context,
        initialTime: TimeOfDay.fromDateTime(initialTime),
        builder: (context, child) {
          return Theme(
            data: ThemeData.light().copyWith(
              primaryColor: const Color(0xFFE33641),
              colorScheme: const ColorScheme.light(
                primary: Color(0xFFE33641),
              ),
            ),
            child: child!,
          );
        },
      );
      
      if (pickedTime != null) {
        // 组合日期和时间
        final DateTime finalDateTime = DateTime(
          pickedDate.year,
          pickedDate.month,
          pickedDate.day,
          pickedTime.hour,
          pickedTime.minute,
        );
        
        // 检查时间是否符合限制
        if (!isStartDate && finalDateTime.isBefore(startDate.value!)) {
          ToastUtil.warning('结束时间不能早于开始时间');
          return;
        }
        
        // 格式化为中文日期格式
        String formattedDate = "${finalDateTime.year}年${finalDateTime.month}月${finalDateTime.day}日 ${finalDateTime.hour.toString().padLeft(2, '0')}:${finalDateTime.minute.toString().padLeft(2, '0')}";
        
        if (isStartDate) {
          startDate.value = finalDateTime;
          startDateText.value = formattedDate;
          // 如果开始时间改变了，需要检查结束时间是否还有效
          if (endDate.value != null && endDate.value!.isBefore(finalDateTime)) {
            endDate.value = null;
            endDateText.value = "";
          }
        } else {
          endDate.value = finalDateTime;
          endDateText.value = formattedDate;
        }
      }
    }
  }
  
  // 打开限制选择器
  void openLimitPicker(BuildContext context) async {
    // 首先清除所有输入框焦点并收起键盘
    clearAllFocus();
    // 添加短暂延迟确保键盘完全收起
    await Future.delayed(const Duration(milliseconds: 150));
    
    showModalBottomSheet(
      context: context,
      builder: (context) => Container(
        color: Colors.white,
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
            ...limitOptions.map((option) => ListTile(
              title: Center(child: Text(option)),
              onTap: () {
                selectedLimit.value = option;
                Get.back();
              },
            )).toList(),
          ],
        ),
      ),
    );
  }
  
  // 打开消费方式选择器
  void openPaymentPicker(BuildContext context) async {
    // 首先清除所有输入框焦点并收起键盘
    clearAllFocus();
    // 添加短暂延迟确保键盘完全收起
    await Future.delayed(const Duration(milliseconds: 150));
    
    showModalBottomSheet(
      context: context,
      builder: (context) => Container(
        color: Colors.white,
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
            ...paymentOptions.map((option) => ListTile(
              title: Center(child: Text(option)),
              onTap: () {
                selectedPayment.value = option;
                Get.back();
              },
            )).toList(),
          ],
        ),
      ),
    );
  }
  

  
  // 监控活动详情文本长度
  void updateDetailsLength(String text) {
    detailsLength.value = text.length;
  }
  
  // 选择活动图片（支持多张图片，学习发布评论实现）
  Future<void> pickActivityImage() async {
    // 首先清除所有输入框焦点并收起键盘
    clearAllFocus();
    // 添加短暂延迟确保键盘完全收起
    await Future.delayed(const Duration(milliseconds: 150));
    
    final ImageSource? source = await _showModernImageSourceDialog();
    if (source == null) return;
    
    try {
      final XFile? image = await _picker.pickImage(
        source: source,
        maxWidth: 1000,
        maxHeight: 1000,
        imageQuality: 85,
      );
      
      if (image != null) {
        // 先添加到本地图片列表以便立即显示
        activityImages.add(image.path);
        ToastUtil.success('图片选择成功');
        
        // 异步上传图片到服务器
        await _uploadActivityImage(File(image.path));
      }
    } catch (e) {
      ToastUtil.error('图片选择失败: ${e.toString()}');
    }
  }

  // 删除活动图片（支持多张图片）
  void removeActivityImage(int index) {
    if (index < activityImages.length) {
      activityImages.removeAt(index);
      ToastUtil.success('图片已删除');
    }
  }

  // 上传活动图片到服务器（支持多张图片，学习发布评论实现）
  Future<void> _uploadActivityImage(File imageFile) async {
    try {
      isUploadingActivityImage.value = true;
      
      // 获取当前用户ID
      final currentUser = userService.currentUser;
      if (currentUser == null) {
        ToastUtil.error('请先登录');
        return;
      }

      print('🚀 开始上传活动图片: ${imageFile.path}');
      print('📝 用户ID: ${currentUser.userid}');

      // 创建FormData
      String fileName = imageFile.path.split('/').last;
      dio.FormData formData = dio.FormData.fromMap({
        'user_id': currentUser.userid.toString(),
        'file': await dio.MultipartFile.fromFile(
          imageFile.path,
          filename: fileName,
        ),
      });

      // 配置Dio客户端 - 处理重定向
      final dioClient = dio.Dio();
      dioClient.options.followRedirects = true; // 自动处理重定向
      dioClient.options.maxRedirects = 5; // 最多5次重定向
      dioClient.options.connectTimeout = Duration(seconds: 30); // 连接超时
      dioClient.options.receiveTimeout = Duration(seconds: 60); // 接收超时

      // 尝试多个可能的端点URL
      final List<String> possibleUrls = [
        'http://124.71.77.44:2233/users/upload_image/', // 带斜杠
        'http://124.71.77.44:2233/users/upload_image',   // 不带斜杠
        'https://124.71.77.44:2233/users/upload_image/', // HTTPS带斜杠
        'https://124.71.77.44:2233/users/upload_image',  // HTTPS不带斜杠
      ];

      dio.Response? response;

      // 逐个尝试URL直到成功
      for (String url in possibleUrls) {
        try {
          print('🌐 尝试上传活动图片到URL: $url');
          
          response = await dioClient.post(
            url,
            data: formData,
            options: dio.Options(
              headers: {
                'Content-Type': 'multipart/form-data',
                'Accept': 'application/json',
              },
              validateStatus: (status) {
                // 接受200-299和307状态码
                return (status! >= 200 && status < 300) || status == 307;
              },
            ),
          );

          print('📊 活动图片响应状态码: ${response.statusCode}');
          print('📄 活动图片响应数据: ${response.data}');

          if (response.statusCode == 200) {
            print('✅ 活动图片成功URL: $url');
            break; // 成功，跳出循环
          } else if (response.statusCode == 307) {
            // 处理重定向
            final location = response.headers['location']?.first;
            if (location != null) {
              print('🔄 活动图片重定向到: $location');
              // 使用重定向的URL再次尝试
              response = await dioClient.post(
                location,
                data: formData,
                options: dio.Options(
                  headers: {
                    'Content-Type': 'multipart/form-data',
                    'Accept': 'application/json',
                  },
                ),
              );
              if (response.statusCode == 200) {
                print('✅ 活动图片重定向成功URL: $location');
                break;
              }
            }
          }
        } catch (urlError) {
          print('❌ 活动图片URL失败 $url: $urlError');
          continue; // 尝试下一个URL
        }
      }

      if (response != null && response.statusCode == 200) {
        final data = response.data;
        print('✅ 活动图片上传响应成功: $data');
        
        if (data is Map && data['status'] == 'success') {
          // 兼容不同的字段名格式：image_url 或 imageUrl
          final uploadedImageUrl = data['image_url'] ?? data['imageUrl'];
          
          if (uploadedImageUrl != null) {
            // 上传成功，更新对应的图片列表
            final imagePath = imageFile.path;
            
            // 找到本地路径对应的索引并替换为网络URL
            final index = activityImages.indexWhere((img) => img == imagePath);
            if (index != -1) {
              activityImages[index] = uploadedImageUrl;
            }
          
            ToastUtil.success('图片上传成功');
            print('🎉 活动图片上传成功，URL: $uploadedImageUrl');
          } else {
            ToastUtil.error('服务器返回的图片URL为空');
            print('❌ 活动图片上传失败，图片URL字段缺失: $data');
          }
        } else {
          ToastUtil.error(data['message'] ?? '图片上传失败');
          print('❌ 活动图片上传失败，响应格式错误: $data');
        }
      } else {
        ToastUtil.error('所有上传端点都失败');
        print('❌ 所有活动图片URL都失败了');
      }
    } catch (e) {
      ToastUtil.error('图片上传失败: ${e.toString()}');
      print('💥 活动图片上传异常: $e');
      print('📋 异常类型: ${e.runtimeType}');
      if (e is dio.DioException) {
        print('🔍 DioException详情:');
        print('   - 状态码: ${e.response?.statusCode}');
        print('   - 响应数据: ${e.response?.data}');
        print('   - 请求URL: ${e.requestOptions.uri}');
      }
    } finally {
      isUploadingActivityImage.value = false;
    }
  }

  /// 显示现代化的图片来源选择弹出框
  Future<ImageSource?> _showModernImageSourceDialog() async {
    ImageSource? selectedSource;
    
    await Get.bottomSheet(
      Container(
        decoration: BoxDecoration(
          color: Colors.white,
          borderRadius: BorderRadius.vertical(top: Radius.circular(20)),
        ),
        child: SafeArea(
          child: Column(
            mainAxisSize: MainAxisSize.min,
            children: [
              // 顶部标题
              Container(
                padding: EdgeInsets.symmetric(vertical: 20),
                child: Column(
                  children: [
                    // 小横条装饰
                    Container(
                      width: 40,
                      height: 4,
                      decoration: BoxDecoration(
                        color: Colors.grey[300],
                        borderRadius: BorderRadius.circular(2),
                      ),
                    ),
                    SizedBox(height: 16),
                    Text(
                      '选择图片来源',
                      style: TextStyle(
                        fontSize: 18,
                        fontWeight: FontWeight.bold,
                        color: Colors.black87,
                      ),
                    ),
                  ],
                ),
              ),
              
              // 选项列表
              Padding(
                padding: EdgeInsets.symmetric(horizontal: 20),
                child: Column(
                  children: [
                    // 拍照选项
                    GestureDetector(
                      onTap: () {
                        selectedSource = ImageSource.camera;
                        Get.back();
                      },
                      child: Container(
                        width: double.infinity,
                        padding: EdgeInsets.symmetric(vertical: 16),
                        decoration: BoxDecoration(
                          color: Colors.grey[50],
                          borderRadius: BorderRadius.circular(12),
                          border: Border.all(color: Colors.grey[200]!),
                        ),
                        child: Row(
                          children: [
                            SizedBox(width: 16),
                            Container(
                              padding: EdgeInsets.all(10),
                              decoration: BoxDecoration(
                                color: Color(0xFFE33641).withOpacity(0.1),
                                borderRadius: BorderRadius.circular(10),
                              ),
                              child: Icon(
                                Icons.camera_alt,
                                color: Color(0xFFE33641),
                                size: 24,
                              ),
                            ),
                            SizedBox(width: 16),
                            Expanded(
                              child: Column(
                                crossAxisAlignment: CrossAxisAlignment.start,
                                children: [
                                  Text(
                                    '拍照',
                                    style: TextStyle(
                                      fontSize: 16,
                                      fontWeight: FontWeight.w500,
                                      color: Colors.black87,
                                    ),
                                  ),
                                  SizedBox(height: 4),
                                  Text(
                                    '拍摄新照片',
                                    style: TextStyle(
                                      fontSize: 13,
                                      color: Colors.blue[600],
                                    ),
                                  ),
                                ],
                              ),
                            ),
                            Icon(
                              Icons.chevron_right,
                              color: Colors.grey[400],
                              size: 20,
                            ),
                            SizedBox(width: 16),
                          ],
                        ),
                      ),
                    ),
                    
                    SizedBox(height: 12),
                    
                    // 从相册选择选项
                    GestureDetector(
                      onTap: () {
                        selectedSource = ImageSource.gallery;
                        Get.back();
                      },
                      child: Container(
                        width: double.infinity,
                        padding: EdgeInsets.symmetric(vertical: 16),
                        decoration: BoxDecoration(
                          color: Colors.grey[50],
                          borderRadius: BorderRadius.circular(12),
                          border: Border.all(color: Colors.grey[200]!),
                        ),
                        child: Row(
                          children: [
                            SizedBox(width: 16),
                            Container(
                              padding: EdgeInsets.all(10),
                              decoration: BoxDecoration(
                                color: Color(0xFFE33641).withOpacity(0.1),
                                borderRadius: BorderRadius.circular(10),
                              ),
                              child: Icon(
                                Icons.photo_library,
                                color: Color(0xFFE33641),
                                size: 24,
                              ),
                            ),
                            SizedBox(width: 16),
                            Expanded(
                              child: Column(
                                crossAxisAlignment: CrossAxisAlignment.start,
                                children: [
                                  Text(
                                    '从相册选择',
                                    style: TextStyle(
                                      fontSize: 16,
                                      fontWeight: FontWeight.w500,
                                      color: Colors.black87,
                                    ),
                                  ),
                                  SizedBox(height: 4),
                                  Text(
                                    '推荐选择',
                                    style: TextStyle(
                                      fontSize: 13,
                                      color: Colors.green[600],
                                    ),
                                  ),
                                ],
                              ),
                            ),
                            Icon(
                              Icons.chevron_right,
                              color: Colors.grey[400],
                              size: 20,
                            ),
                            SizedBox(width: 16),
                          ],
                        ),
                      ),
                    ),
                  ],
                ),
              ),
              
              // 取消按钮
              Padding(
                padding: EdgeInsets.all(20),
                child: SizedBox(
                  width: double.infinity,
                  height: 48,
                  child: ElevatedButton(
                    onPressed: () => Get.back(),
                    style: ElevatedButton.styleFrom(
                      backgroundColor: Colors.grey[200],
                      foregroundColor: Colors.black87,
                      shape: RoundedRectangleBorder(
                        borderRadius: BorderRadius.circular(12),
                      ),
                      elevation: 0,
                    ),
                    child: Text(
                      '取消',
                      style: TextStyle(
                        fontSize: 16,
                        fontWeight: FontWeight.w500,
                      ),
                    ),
                  ),
                ),
              ),
            ],
          ),
        ),
      ),
      isScrollControlled: true,
    );
    
    return selectedSource;
  }
  
  // 提交表单
  Future<void> submitForm() async {
    // ✅ 首先验证用户登录状态
    if (userService.currentUser == null || !userService.isLoggedIn) {
      ToastUtil.error('请先登录后再发布活动');
      print('❌ 用户未登录，无法发布活动');
      return;
    }
    
    // 🔍 调试输出当前用户信息
    print('🔍 =============== 活动发布用户信息调试 ===============');
    print('📱 当前用户ID: ${publisherId}');
    print('👤 当前用户名: ${publisherNickname}');
    print('🖼️ 当前头像: ${publisherAvatarUrl}');
    print('✍️ 当前签名: ${publisherSignature}');
    print('🔐 登录状态: ${userService.isLoggedIn}');
    print('📊 完整用户对象: ${userService.currentUser != null ? "存在" : "不存在"}');
    print('🏁 ======================================================');
    
    // 表单验证
    if (titleController.text.isEmpty) {
      ToastUtil.error('请输入活动标题');
      return;
    }
    
    if (startDate.value == null) {
      ToastUtil.error('请选择开始时间');
      return;
    }
    
    if (endDate.value == null) {
      ToastUtil.error('请选择结束时间');
      return;
    }
    
    if (peopleCountController.text.isEmpty) {
      ToastUtil.error('请输入参与人数');
      return;
    }
    
    // 验证人数是否为有效数字
    final peopleCount = int.tryParse(peopleCountController.text);
    if (peopleCount == null || peopleCount <= 0) {
      ToastUtil.error('请输入有效的参与人数');
      return;
    }
    
    if (detailsController.text.isEmpty) {
      ToastUtil.error('请输入活动详情');
      return;
    }
    
    // 开始加载
    isLoading.value = true;
    
    try {
      // 🕒 格式化开始时间和结束时间为API要求的格式（按照MyApplication2的做法）
      final String formattedStartTime = formatDateTimeForApi(startDate.value!);
      final String formattedEndTime = formatDateTimeForApi(endDate.value!);
      
      // 🔍 调试输出时间信息
      print('🕒 =============== 活动时间调试（修复版）===============');
      print('⏰ 开始时间 (activityPublishTime): $formattedStartTime');
      print('⏰ 结束时间 (extraData.activityEndTime): $formattedEndTime');
      print('📋 参考MyApplication2项目的正确做法');
      print('🏁 ====================================================');
      
      // 准备活动类型数组（包含消费方式和限制）
      List<String> activityType = [selectedPayment.value];
      if (selectedLimit.value != "无限制") {
        activityType.add(selectedLimit.value);
      }

      // 准备活动标签数组（不使用类别）
      List<String> activityTags = [];

      // 准备活动图片数组（支持多张图片）
      List<String>? activityImageUrls;
      // 过滤出网络图片URL
      final networkImages = activityImages
          .where((img) => img.startsWith('http'))
          .toList();
      
      if (networkImages.isNotEmpty) {
        activityImageUrls = networkImages;
      }

      // 调用发布活动API（按照MyApplication2的正确做法）
      final result = await ActivityApi.publishActivity(
        activityTitle: titleController.text.trim(),
        publisherId: publisherId,
        publisherNickname: publisherNickname,
        activityPublishTime: formattedStartTime, // ✅ 只传开始时间（参考MyApplication2）
        latitude: latitude,
        longitude: longitude,
        activityDetails: detailsController.text.trim(),
        activityLocation: location.value,
        activityImages: activityImageUrls, // 传入活动图片（支持多张）
        activityType: activityType,
        activityTags: activityTags,
        activityMaxParticipants: peopleCount,
        publisherAvatarUrl: publisherAvatarUrl.isEmpty ? null : publisherAvatarUrl,
        publisherSignature: publisherSignature.isEmpty ? null : publisherSignature,
        publisherTags: ["新用户"], // 可以根据实际情况设置
        free: PermissionUtil.calculatePublishActivityFree(), // 🎯 动态计算免费发布权限（模仿MyApplication2）
        extraData: { // ✅ 按照MyApplication2的做法传递结束时间
          "activityEndTime": formattedEndTime,  // 🎯 关键：结束时间字段名与MyApplication2一致
          "duration": _calculateDuration(),     // 活动持续时间（小时）
        },
      );

      // 处理API响应 - 修复字段名问题
      print('🔍 处理API响应: ${result}');
      print('🔍 result[success]: ${result['success']}');
      print('🔍 result[status]: ${result['status']}');
      
      // 兼容两种响应格式：success: true 或 status: "success"
      final isSuccess = result['success'] == true || result['status'] == 'success';
      print('🔍 最终判断结果: $isSuccess');
      
      if (isSuccess) {
        print('✅ 进入成功处理逻辑');
        
        // 🎯 增加发布活动计数（模仿MyApplication2的逻辑）
        PermissionUtil.incrementPublishActivityCount();
        
        // 获取积分变化（发布活动奖励积分）
        final pointsChange = result['pointsChange'] ?? 0;
        
        // 🎯 处理积分变化并更新权限（模仿MyApplication2的changeUserPoints）
        if (pointsChange != 0) {
          PermissionUtil.changeUserPoints(pointsChange);
        }
        
        // 显示居中的成功对话框，与发布评论保持一致
        _showSuccessDialog(
          message: result['message'] ?? '活动发布成功',
          pointsChange: pointsChange,
        );
        print('✅ 成功对话框显示完成');
      } else {
        print('❌ API响应失败');
        ToastUtil.error(result['message'] ?? '发布失败，请重试');
      }
    } catch (e) {
      ToastUtil.error('发布失败: ${e.toString()}');
    } finally {
      // 结束加载
      isLoading.value = false;
    }
  }

  /// 格式化日期时间为API要求的格式
  String formatDateTimeForApi(DateTime dateTime) {
    return "${dateTime.year}-${dateTime.month.toString().padLeft(2, '0')}-${dateTime.day.toString().padLeft(2, '0')} ${dateTime.hour.toString().padLeft(2, '0')}:${dateTime.minute.toString().padLeft(2, '0')}:00";
  }

  /// 计算活动持续时间（小时）
  double _calculateDuration() {
    if (startDate.value == null || endDate.value == null) {
      return 0.0;
    }
    
    final duration = endDate.value!.difference(startDate.value!);
    final hours = duration.inMinutes / 60.0;
    
    print('⏱️ 活动持续时间: ${hours.toStringAsFixed(1)}小时');
    return double.parse(hours.toStringAsFixed(1));
  }



  /// 清空表单
  void _clearForm() {
    titleController.clear();
    peopleCountController.clear();
    detailsController.clear();
    startDate.value = null;
    startDateText.value = "";
    endDate.value = null;
    endDateText.value = "";

    selectedLimit.value = "无限制";
    selectedPayment.value = "我买单";
    detailsLength.value = 0;
    activityImages.clear(); // 清空活动图片列表
    isUploadingActivityImage.value = false;
  }

  /// 显示成功对话框（与发布评论保持一致）
  void _showSuccessDialog({
    required String message,
    required int pointsChange,
  }) {
    Get.dialog(
      Dialog(
        backgroundColor: Colors.transparent,
        child: Container(
          margin: const EdgeInsets.symmetric(horizontal: 40),
          padding: const EdgeInsets.all(24),
          decoration: BoxDecoration(
            color: Colors.white,
            borderRadius: BorderRadius.circular(16),
            boxShadow: [
              BoxShadow(
                color: Colors.black.withOpacity(0.1),
                blurRadius: 10,
                spreadRadius: 2,
              ),
            ],
          ),
          child: Column(
            mainAxisSize: MainAxisSize.min,
            children: [
              // 成功图标
              Container(
                width: 64,
                height: 64,
                decoration: BoxDecoration(
                  color: const Color(0xFF4CAF50),
                  shape: BoxShape.circle,
                ),
                child: const Icon(
                  Icons.check,
                  color: Colors.white,
                  size: 40,
                ),
              ),
              
              const SizedBox(height: 24),
              
              // 标题
              const Text(
                '发布成功！',
                style: TextStyle(
                  fontSize: 20,
                  fontWeight: FontWeight.bold,
                  color: Colors.black87,
                ),
              ),
              
              const SizedBox(height: 12),
              
              // 消息内容
              Text(
                message,
                textAlign: TextAlign.center,
                style: TextStyle(
                  fontSize: 16,
                  color: Colors.grey[600],
                  height: 1.4,
                ),
              ),
              
              if (pointsChange != 0) ...[
                const SizedBox(height: 8),
                Container(
                  padding: EdgeInsets.symmetric(horizontal: 12, vertical: 6),
                  decoration: BoxDecoration(
                    color: pointsChange > 0 ? Colors.green[50] : Colors.orange[50],
                    borderRadius: BorderRadius.circular(12),
                    border: Border.all(
                      color: pointsChange > 0 ? Colors.green[200]! : Colors.orange[200]!,
                      width: 1,
                    ),
                  ),
                  child: Text(
                    pointsChange > 0 ? '获得积分: +$pointsChange' : '消耗积分: ${pointsChange.abs()}',
                    style: TextStyle(
                      fontSize: 14,
                      color: pointsChange > 0 ? Colors.green[700] : Colors.orange[700],
                      fontWeight: FontWeight.w600,
                    ),
                  ),
                ),
              ],
              
              const SizedBox(height: 32),
              
              // 确认按钮
              SizedBox(
                width: double.infinity,
                height: 44,
                child: ElevatedButton(
                  onPressed: () {
                    print('🔘 用户点击确定按钮');
                    print('📍 当前路由信息: ${Get.currentRoute}');
                    print('📚 路由栈深度: ${Get.routing.current}');
                    
                    // 关闭对话框
                    Get.back();
                    print('✅ 成功对话框已关闭');
                    print('📍 关闭对话框后路由: ${Get.currentRoute}');
                    
                    // 清空表单
                    _clearForm();
                    print('✅ 表单清空完成');
                    
                    // 🎯 通知发布成功 - 触发数据刷新和跳转
                    _notifyPublishSuccess();
                    print('✅ 跳转通知完成');

                    // 返回上一页（与发布评论保持一致）
                    print('🔙 准备返回上一页');
                    print('📍 返回前路由: ${Get.currentRoute}');
                    Get.back();
                    print('✅ 返回上一页完成');
                    print('📍 返回后路由: ${Get.currentRoute}');
                  },
                  style: ElevatedButton.styleFrom(
                    backgroundColor: const Color(0xFFE33641),
                    shape: RoundedRectangleBorder(
                      borderRadius: BorderRadius.circular(8),
                    ),
                    elevation: 0,
                  ),
                  child: const Text(
                    '确定',
                    style: TextStyle(
                      fontSize: 16,
                      fontWeight: FontWeight.w500,
                      color: Colors.white,
                    ),
                  ),
                ),
              ),
            ],
          ),
        ),
      ),
      barrierDismissible: false, // 禁止点击外部关闭
    );
  }
  
  /// 通知发布成功 - 触发刷新和跳转
  void _notifyPublishSuccess() {
    try {
      print('🚀 开始处理活动发布成功跳转...');
      
      // 🎯 方式一：尝试直接操作已存在的控制器（如果用户已经在主页面）
      try {
        // 检查是否有MainController（主页面底部导航栏控制器）
        if (Get.isRegistered<MainController>()) {
          final mainController = Get.find<MainController>();
          
          // 切换到"一起玩"标签页（索引1）
          mainController.switchTab(1);
          print('✅ 已切换到主页面的"一起玩"标签页');
          
          // 延迟处理PlaysController，确保页面已加载
          Future.delayed(Duration(milliseconds: 800), () {
            if (Get.isRegistered<PlaysController>()) {
              final playsController = Get.find<PlaysController>();
              
              // 发送活动发布成功事件（触发数据刷新）
              playsController.notifyPublishSuccess('activity');
              print('✅ 活动发布成功事件已发送');
              
              // 再延迟切换到活动子标签页
              Future.delayed(Duration(milliseconds: 500), () {
                if (Get.isRegistered<PlaysController>()) {
                  final controller = Get.find<PlaysController>();
                  // 切换到活动tab（索引1）
                  controller.changeTabIndex(1);
                  print('🎯 已切换到活动标签页（索引1）');
                }
              });
            }
          });
          
          print('✅ 直接方式跳转成功');
          return;
        }
      } catch (directError) {
        print('⚠️ 直接方式失败，尝试导航方式: $directError');
      }
      
      // 🎯 方式二：导航到主页面然后切换到"一起玩"标签页
      print('🔄 使用导航方式跳转到主页面...');
      
      // 尝试不同的导航方法跳转到主页面
      try {
        // 方法1：跳转到主页面（带底部导航栏）
        Get.offAllNamed('/system_main');
        print('✅ 成功跳转到主页面');
      } catch (e1) {
        try {
          // 方法2：使用根路由
          Get.offAllNamed('/');
          print('✅ 成功跳转到根页面');
        } catch (e2) {
          print('❌ 所有导航方式都失败，使用降级方案');
          Get.back(); // 至少返回上一页
          return;
        }
      }
      
      // 导航成功后，延迟处理主页面和PlaysController
      Future.delayed(Duration(milliseconds: 1200), () {
        try {
          // 先切换到"一起玩"标签页
          if (Get.isRegistered<MainController>()) {
            final mainController = Get.find<MainController>();
            mainController.switchTab(1); // 切换到"一起玩"标签页（索引1）
            print('✅ 已切换到主页面的"一起玩"标签页');
            
            // 延迟处理PlaysController
            Future.delayed(Duration(milliseconds: 800), () {
              if (Get.isRegistered<PlaysController>()) {
                final playsController = Get.find<PlaysController>();
                
                // 发送活动发布成功事件（触发数据刷新）
                playsController.notifyPublishSuccess('activity');
                print('✅ 活动发布成功事件已发送');
                
                // 再延迟切换到活动子标签页
                Future.delayed(Duration(milliseconds: 500), () {
                  if (Get.isRegistered<PlaysController>()) {
                    final controller = Get.find<PlaysController>();
                    // 切换到活动tab（索引1）
                    controller.changeTabIndex(1);
                    print('🎯 已切换到活动标签页（索引1）');
                  } else {
                    print('❌ PlaysController未注册，无法切换标签页');
                  }
                });
              } else {
                print('❌ PlaysController未注册');
              }
            });
          } else {
            print('❌ MainController未注册，无法切换到一起玩标签页');
          }
        } catch (innerError) {
          print('❌ 控制器操作失败: $innerError');
        }
      });
      
      print('✅ 活动发布成功跳转流程已启动');
    } catch (e) {
      print('❌ 发送活动发布成功通知失败: $e');
      // 📱 最终降级方案
      Get.back();
    }
  }

  @override
  void onReady() {
    super.onReady();
    _initData();
  }

  @override
  void onClose() {
    // 释放TextEditingController
    titleController.dispose();
    peopleCountController.dispose();
    detailsController.dispose();
    
    // 释放FocusNode
    titleFocusNode.dispose();
    peopleCountFocusNode.dispose();
    detailsFocusNode.dispose();
    
    super.onClose();
  }
}
